{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 分类训练"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 一，机器学习的HelloWorld ，一个新的分类算法，都会看看在MNIST的上的执行结果<br>\n",
    "通过Mnist 手写数据集来了解分类,下载地址：http://yann.lecun.com/exdb/mnist/  <br>\n",
    "这些数据是 由美国高中生和人口调查局，手写数字的图片， 大概有7万个  <br>\n",
    "每张图片中的数字，就代表其数据集的标记<br>\n",
    "这些数据集被广泛使用，也被称为是机器学习里面的“Hello world”<br>\n",
    "一般有人写了分类算法，就会先拿这些数据集来执行，查看执行结果，非常有利用我们初期学习的人拿来学习<br>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.压缩 <br>\n",
    "上面这种byte二进制文件下载下来后怎么解压缩呢？\t <br>\n",
    "\t包的解压缩，需要有包的格式说明文件，才能解包 <br>\n",
    "\t说明文件内容，也在这里可见 http://yann.lecun.com/exdb/mnist/ ,例：<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|offset |type  |        value  |        description|柳备注|\n",
    "|:-|:---|:----|:------|:------|\n",
    "|0000  |   32 bit integer | 0x00000803(2051) |magic number |前四个Byte（0000-0003）表示，本文件的ID号，值是2051|\n",
    "|0004  |   32 bit integer | 60000        |    number of images |接着四个Byte（0004-0007）表示本文件包含的图片数，值是6000个|\n",
    "|0008  |   32 bit integer | 28          |     number of rows |接着四个Byte（0004-0007）表示单个图片的像素行数，是28|\n",
    "|0012  |   32 bit integer | 28          |     number of columns |接着四个Byte（0004-0007）表示单个图片的像素列,是28|\n",
    "|0016  |   unsigned byte  | ??          |     pixel|一个Byte,表示一个像素|\n",
    "|0017  |   unsigned byte  | ??          |     pixel|一个Byte,表示一个像素|\n",
    "|........|\n",
    "|xxxx  |   unsigned byte  | ??          |     pixel|一个Byte,表示一个像素|\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "压缩命令如下"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'\\x02'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import struct   # 压缩解压缩的包\n",
    "# struct.pack('>i',2) # 高位字节\n",
    "struct.pack('>B',2) # 高位字节"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*pack 压缩\n",
    "\n",
    "struct.pack('>i',2)  -->  将2压缩压成int的integer整形\n",
    "\n",
    "  结果：b'\\x00\\x00\\x00\\x02'  -->  是四个字节\n",
    "\n",
    "struct.pack('>B',2) # 将2压缩压成unsignedchar的integer整形\n",
    "\n",
    "结果：b'\\x02'  -->  是一个字节\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "![jupyter](./g1.png)\n",
    "![jupyter](./g2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.解压缩"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**解压缩train-images-idx3-ubyte** <br>\n",
    "&nbsp;描述如下:<br>\n",
    "TRAINING SET IMAGE FILE (train-images-idx3-ubyte):<br>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|offset |type  |        value  |        description|柳备注|\n",
    "|:-|:---|:----|:------|:------|\n",
    "|0000  |   32 bit integer | 0x00000803(2051) |magic number |前四个Byte（0000-0003）表示，本文件的ID号，值是2051|\n",
    "|0004  |   32 bit integer | 60000        |    number of images |接着四个Byte（0004-0007）表示本文件包含的图片数，值是6000个|\n",
    "|0008  |   32 bit integer | 28          |     number of rows |接着四个Byte（0004-0007）表示单个图片的像素行数，是28|\n",
    "|0012  |   32 bit integer | 28          |     number of columns |接着四个Byte（0004-0007）表示单个图片的像素列,是28|\n",
    "|0016  |   unsigned byte  | ??          |     pixel|一个Byte,表示一个像素|\n",
    "|0017  |   unsigned byte  | ??          |     pixel|一个Byte,表示一个像素|\n",
    "|........|\n",
    "|xxxx  |   unsigned byte  | ??          |     pixel|一个Byte,表示一个像素|\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pixels are organized row-wise. Pixel values are 0 to 255. 0 means background (white), 255 means foreground (black)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bytes'>\n",
      "(2051, 60000, 28, 28)\n",
      "47040000\n"
     ]
    }
   ],
   "source": [
    "import struct  # 导入模块\n",
    "with open('./MNIST_data/train-images-idx3-ubyte', 'rb') as f:   # 读取文件\n",
    "    buffer = f.read(4*4) # 每4个Byte为一组，读取4组\n",
    "    print(type(buffer))\n",
    "    head = struct.unpack('>iiii',buffer)  # 解压缩buffer，4组数据的解压缩方式都是int（十进制的整数）\n",
    "    # head = struct.unpack('>4i',buffer) # 这种写法跟上面是等价的\n",
    "    print(head)  # 可见四个整数\n",
    "    length = head[1] * head[2]  * head[3]   # 接下来计算一下，上面四组数据意外，还剩多少个bit : 60000个图片*每个图片都是28*28像素\n",
    "    print(length)\n",
    "    buffer = f.read(length)  # 我怎么感觉这里读取length是错误的，应该读取是 前四组Byte以后接下来的bit\n",
    "#   print(buffer)\n",
    "    data = struct.unpack('>{}B'.format(length),buffer)  # 将buffer解压缩，所有的（length个）字节的解压缩方式都是B(unsigned Byte)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47040000"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(data)  # 查看一下长度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(data) # 类型是元组序列"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.显示图片"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "imgs = np.reshape(data, (head[1], head[2], head[3]))  # 将data转换成一个三维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 28, 28)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imgs.shape  # 查看这个三维数组的构成，60000个(28x28)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt  # 导入模块\n",
    "for i in range(3):   # 给i逐步取值 0，1，2\n",
    "    print(i)\n",
    "    plt.imshow(imgs[i], cmap = 'gray')  # 生成这三个图：imgs[0]，imgs[1]，imgs[2] ，颜色'gray'\n",
    "    plt.show()  # 显示图片"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.显示图片，第二种方式 <br>\n",
    "加载一下本地这个数据：\\模块五机器学习\\第一章：机器学习（第九周课程）\\4.分类训练\\代码\\mldata\\mnist-original.mat <br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\feature_extraction\\text.py:17: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated since Python 3.3, and in 3.9 it will stop working\n",
      "  from collections import Mapping, defaultdict\n"
     ]
    }
   ],
   "source": [
    "import sklearn\n",
    "from sklearn.datasets import fetch_mldata   # 通过sklearn加载（numpy/pandas也可以加载）\n",
    "# fetch_mldata从本地抓取数据方法如下：\n",
    "mnist = fetch_mldata('MNIST original', data_home='./')   \n",
    "# 也可以从网络抓取数据:\n",
    "# mnist = fetch_mldata('完整的url')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1）** 上面是课件将的方法，实际执行之后报错了。<br>\n",
    "问了一下助教，是版本问题,解决办法如下：<br>\n",
    "降低sklearn版本，卸载之前的,安装这个版本0.19.2 <br>\n",
    "pip  uninstall  scikit_learn <br>\n",
    "pip  install  scikit_learn==0.19.2 <br>\n",
    "**2）** 网上看到这个文章：https://bingwong.org/2018/11/13/123.html ： <br>\n",
    "sklearn 0.20版本后不再提供fetch_mldata的数据下载<br>\n",
    "根据网上的文章的命令，略做修改，使用下面的命令行成功了：<br>\n",
    "from sklearn.datasets import fetch_openml <br>\n",
    "mnist = fetch_openml('mnist_784', version='active', data_home='./') <br>\n",
    "但是查看结果却获得了不一样的值，所以改用助教老师讲的方法 <br>\n",
    "**3）** 安装scikit_learn==0.19.2的后，报错 <br>\n",
    "error: Microsoft Visual C++ 14.0 is required. Get it with \"Microsoft Visual C++ Build Tools\": https://visualstudio.microsoft.com/downloads/<br>\n",
    "结果安装了 C++ 14.0之后依然报相同的错误。<br>\n",
    "**4）** 再次咨询助教老师, 让看<br>\n",
    "https://blog.csdn.net/weixin_40547993/article/details/89399825 最后的解决办法<br>\n",
    "下载了<visualcppbuildtools_full.exe>默认安装后解决问题<br>\n",
    "已经将<visualcppbuildtools_full.exe>存在了本机：\\python\\教程PPT\\模块五机器学习\\第一章：机器学习（第九周课程）\\保存的有用的exe<br>\n",
    "**5）** 查看当前版本sklearn<br>\n",
    "import sklearn<br>\n",
    "print('Your version is {}'.format(sklearn.__version__))  <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your version is 0.19.2\n"
     ]
    }
   ],
   "source": [
    "import sklearn\n",
    "print('Your version is {}'.format(sklearn.__version__))  # 查看当前版本"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 安装完0.19sklearn之后，再次执行\n",
    "import sklearn\n",
    "from sklearn.datasets import fetch_mldata   # 通过sklearn加载（numpy/pandas也可以加载）\n",
    "# fetch_mldata从本地抓取数据方法如下：\n",
    "mnist = fetch_mldata('MNIST original', data_home='./')   \n",
    "# 也可以从网络抓取数据:\n",
    "# mnist = fetch_mldata('完整的url')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'DESCR': 'mldata.org dataset: mnist-original',\n",
       " 'COL_NAMES': ['label', 'data'],\n",
       " 'target': array([0., 0., 0., ..., 9., 9., 9.]),\n",
       " 'data': array([[0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        ...,\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mnist  # 是字典，data是独热编码"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "有上可见mnist其实是个字典，一共有四个键值对儿<br>\n",
    "* DESCR 对数据集mnist描述\n",
    "* COL_NAMES 说明mnist一共有两个数据列：标签和数据\n",
    "* target 包含一个带有标签的数组\n",
    "* data  包含一个数组，每个实例为一行，每个特征为一列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, y = mnist['data'], mnist['target'] # 获取数据（训练集）和标签"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000, 784)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape   # 可以看到X是个二维数组，一共有70000个，每个有784（是像素）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000,)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.shape   # 标签有70000个 数字"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_digit = X[36000]   # 取第36000个数据拿出来\n",
    "some_digit_image = some_digit.reshape(28, 28)   # 将这个数据（784个像素），改成28*28的二维数组（28*28像素）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(some_digit_image, cmap = matplotlib.cm.binary)   \n",
    "plt.show()  # 查看一下"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[36000]  # 查看一下标签跟上面的显示是否一致"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 二，建立测试集和训练集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]\n",
    "# 训练集数据X_train取值范围是 X[:60000] ： 前60000个X\n",
    "# 训练集标签y_train的取值范围是 y[60000:] ： 前60000个y\n",
    "# 测试集集数据X_test取值范围是 X[60000:] ： 第60000-第70000个X\n",
    "# 训练集标签y_test的取值范围是 y[60000:] ： 第60000-第70000个y\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([19870, 59962, 46286, ..., 12628, 39776, 57657])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将数据集合交叉洗牌，交叉验证时，每个子集合数据分布均匀，有些机器学习算法对训练实例的顺序敏感\n",
    "# 柳：原始的mnist数据可能连续的数据，比如100个5或者什么数字，这样的情况会影响机器学习的效果，通过交叉洗牌将原始数据打乱排序是分布均匀。\n",
    "import numpy as np\n",
    "shuffle_index = np.random.permutation(60000)  # shuffle_index是60000个数字的随机排列\n",
    "shuffle_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, y_train = X_train[shuffle_index], y_train[shuffle_index]   # 利用shuffle_index将，训练集重新排列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       ...,\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 三，训练一个二元分类器 <br>\n",
    "二元就是说，输出结果是二元的：是/不是"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, ..., False, False, False])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 识别数字5 ，二元分类5或者非5\n",
    "# 创建目标向量\n",
    "y_train_5 = (y_train == 5)  # 原来的标签都是数字，我们改成TrueFalse的格式，表示是/不是5\n",
    "# ()中可以写5， 5.0，5. 都行， 括号也可以不加，因为==的优先级高于=\n",
    "y_train_5   # 输出结果是一维序列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, ..., False, False, False],\n",
       "       [False, False, False, ..., False, False,  True],\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       ...,\n",
       "       [False,  True,  True, ..., False, False, False],\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       [ True, False, False, ..., False, False, False]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_5.reshape(20, -1)  # 将一维序列塑形成二维矩阵，便于查看"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_5 = (y_test == 5)   # 同样的对测试集标签也修改一下，变成True/False格式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ True])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# SGD 梯度下降 分类器， 适合非常大的数据集，独立处理训练集数据，一次一个，适合在线学习，\n",
    "from sklearn.linear_model import SGDClassifier  # 加载这个分类器\n",
    "\n",
    "sgd_clf = SGDClassifier(random_state = 42) # 给一个random_state值，让每次运行取值固定\n",
    "sgd_clf.fit(X_train, y_train_5)   # fit训练集和上面加工过的True/False标签，来训练模型\n",
    "\n",
    "sgd_clf.predict([some_digit])  # 接下来进行预测，预测some_digit是不是5 （上面通过图片显示我们看见了它是5，所以结果应该是True）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 性能考核"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 一，使用交叉验证测量精度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n",
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n",
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.9628 , 0.96225, 0.95185])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 评估分类器比评估回归器要困难得多\n",
    "\n",
    "from sklearn.model_selection import cross_val_score\n",
    "cross_val_score(sgd_clf, X_train, y_train_5, cv=3, scoring=\"accuracy\")  \n",
    "# sgd_clf 使用的分类器\n",
    "# 使用的训练集，训练标签\n",
    "# cv交叉训练次数 3：均等分为3分，拿每两个做训练集，1一个作为验证集，可以得到3组精度\n",
    "# scoring=\"accuracy\" 进行经度测试\n",
    "# 丛结果上看：3个折叠，正确率达到 96% 以上"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "丛上面结果上看，正确率都在96%以上，但是这个结果可以信任么？<br>\n",
    "下面做个试验来验证一下:做一个精度很低的函数看看他的精度计算出来是什么样子的<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 把每张图都分类成 非5\n",
    "from sklearn.base import BaseEstimator\n",
    "class Never5Classifier(BaseEstimator):\n",
    "    def fit(self, X, y=None):\n",
    "        pass   # 没有定义，只继承基类\n",
    "    def predict(self, X):\n",
    "        return np.zeros((len(X), 1), dtype=bool)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "numpy.zeros是个写0的函数，比如：<br>\n",
    "numpy.zeros(2,3)就是写2行3列的0，<br>\n",
    "所以，np.zeros((len(X), 1)就是写，len(X)行1列的0，<br>\n",
    "dtype=bool，表示用波尔显示，即显示成为False<br>\n",
    "len(X)又是多少呢，从上面我们知道X是70000行784列的矩阵，len(X)的到矩阵的行数，所以是7000<br>\n",
    "所以我们知道，np.zeros((len(X), 1), dtype=bool)就是返回1列70000行的False,如下"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False],\n",
       "       [False],\n",
       "       [False],\n",
       "       ...,\n",
       "       [False],\n",
       "       [False],\n",
       "       [False]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((len(X), 1), dtype=bool)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也就是说使用我们做成的这个估算器，无论输入的数据是什么样（无论数据是不是5）的，结果一律是False，即非五<br>\n",
    "照理来说它的精度是很差的，我们实际计算一下看看，会发现精度居然都在90%以上，如下"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.91185, 0.90705, 0.91005])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "never_5_clf = Never5Classifier()\n",
    "cross_val_score(never_5_clf, X_train, y_train_5, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为什么呢？<br>\n",
    "* 准确率超过90% ，因为5的图像大约只有10%，你猜一张图不是5， 90%的时间你都是正确的\n",
    "* 这说明准确率无法成为分类器的首要性能指标，特别是当你处理偏科数据集， 某些类比其他类更为频繁<br>\n",
    "<br>所以，交叉验证来验证估算器是可以的，但是验证分类器就不是那么好用了。<br>\n",
    "我们期望对分类器的验证可以验证这几个方面<br>\n",
    "1 是5判断的准确率<br>\n",
    "2 非5判断的准确率<br>\n",
    "3 是否可以找出所有5<br>\n",
    "4 是否可以找出所有非5<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 二，混淆矩阵"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 评估分类器性能的更好方法是混淆矩阵<br>\n",
    " A类别实例被分为B类别次数<br>\n",
    " 想要知道分类器将数字3和数字5混淆多少次，通过混淆矩阵的5行3列<br>\n",
    " 如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n",
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n",
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_predict\n",
    "y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)  # cv=3跟上面的意思是一样的，分成3组两组训练1组验证\n",
    "# y_train_pred是得到的预测值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**与 cross_val_score 相比**\n",
    "* 同样执行交叉验证\n",
    "* 返回的不是评估分数，是每个折叠的预测\n",
    "* 每一个实例在模型预测时使用的数据，在训练期间从未见过"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[54281,   298],\n",
       "       [ 2164,  3257]], dtype=int64)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "confusion_matrix(y_train_5, y_train_pred)  # 将预测值和实际值进行比较"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 输出的解释：行表示实际类别，列表示预测类别，数字是对应的个数：\n",
    "\n",
    "|实际\\预测 |预测为非5  | 预测为5  |                                                         \n",
    "|:------|:------|:------|\n",
    "|**实际是非5**  |  53804 | 775 |\n",
    "|**实际是5**  |   1379 |4042  |  \n",
    "\n",
    "这种衡量方式太复杂，我们可以用更简单的指标<br>\n",
    "下面是理想的结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[54579,     0],\n",
       "       [    0,  5421]], dtype=int64)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_perfect_predictions = y_train_5\n",
    "confusion_matrix(y_train_5, y_train_perfect_predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 三，正类预测的准确率 被称为分类器的精度\n",
    "### 1，计算公式\n",
    "\n",
    "$\n",
    "\\text{精度} = \\cfrac{TP真正类}{TP真正类 + FP假正类}\n",
    "$\n",
    "<br>\n",
    "* 精度：正确检测为正类数量/所有检测为正类的数量<br>\n",
    "* TP是真正类的数量，FP是假正类的数量<br>\n",
    "<br>\n",
    "\n",
    "\n",
    "$\n",
    "\\text{召回率TPR} = \\cfrac{TP真正类}{TP真正类 + FN假负类}\n",
    "$\n",
    "<br>\n",
    "* 召回率：正确检测为正类数量/所有真正的正类数量<br>\n",
    "* FN是假负类的数量\n",
    "![jupyter](./zhaohui.jpg)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.精度和召回率的计算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9161744022503516"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import precision_score, recall_score # 载入模块\n",
    "precision_score(y_train_5, y_train_pred) # 4327 / 4327 + 1276  # 把真实的标签和预测的标签放进去就可以计算出精度"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的结果可以理解为，做出的分类中，70%的判断是正确的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6008116583656152"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred)    #  4327 / 4327 + 1094 # 把真实的标签和预测的标签放进去就可以计算召回率"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的结果可以理解为，把正确找出了82%的目标值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "精度和召回率合成单一指标，成为 F1 分数，谐波平均值<br>\n",
    "平均值平等对待所有的值，谐波平均值会给予较低值更高的权重，只有召回率和精度都很高时，才能获得较高的F1分数<br>\n",
    "F1的计算公式如下："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\n",
    "F_1 = \\cfrac{2}{\\cfrac{1}{\\text{precision}} + \\cfrac{1}{\\text{recall}}} = 2 \\times \\cfrac{\\text{precision}\\, \\times \\, \\text{recall}}{\\text{precision}\\, + \\, \\text{recall}} = \\cfrac{TP}{TP + \\cfrac{FN + FP}{2}}\n",
    "$\n",
    "<br><br>\n",
    "下面的方法可以计算出F1的值，每次计算的精度值和召回率值可能又偏差但是F1值却是很小的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7257130124777184"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score\n",
    "f1_score(y_train_5, y_train_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<u>课件性能考核03</u>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.精度/召回率权衡"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 原理：阈值\n",
    "F1分数对那些具有相近精度和召回率 分类器更有利，精度和召回率越高，F1也越高，<br>\n",
    " 但是由于客观条件，可能很难做到精度和召回率都很高，在条件固定的情况下，精度和召回率肯定是此消彼长的，<br>\n",
    " 让精度和召回率得到类似的分数，这不一定符合你的期望，你可能只能二选其一<br>\n",
    " 有时候你更关心精度，有时你能关心召回率<br>\n",
    " 比如，训练一个分类器检测，来挑选适宜儿童观看的视频，<br>\n",
    " 你可能要求哪怕拦截了很多好的视频（低召回率），但必须保证保留下来的都是安全的视频（高精度）<br>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "![jupyter](./quanheng.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的图形解释线性模型SGD的工作原理是:通过阈值来判断,可以通过阈值的调整来空值精度<br>\n",
    "* SGDClassifier对每个实例基于决策函数计算一个分值，大于阀值为正类，否则为负类\n",
    "* 中间阀值右侧找到4个真正类 真5 ， 一个假正类 6， 精度为 4/5 80%\n",
    "* 在所有的6个 真正的5 中，分类器找到了4个，召回率为 4/6 67%\n",
    "* 提高阀值，向右移动，精度提高，召回降低\n",
    "* 反之阀值降低，召回提高，精度降低\n",
    "* SKlearn不可以直接设置阀值，可以访问决策分数，\n",
    "* SGDClassifier 默认阀值为0 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>课件性能考核04</u>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " #### 如何设置阀值?\n",
    "##### ①pred_proba\n",
    " 用predict_proba得到每个实例属于正类的概率，然后对概率切一下。<br>\n",
    " 以LogisticRegression（逻辑回归类）为例 <br>\n",
    " > clf = LogisticRegression()<br>\n",
    " > clf.fit(X_train, y_train)<br>\n",
    " > pred_proba = clf.predict_proba(X_test)[:, 1]       # _pred_proba是每个实例为真的概率_<br>\n",
    " > threshold = 0.75    # _阀值设置为0.75_ <br>\n",
    " > pred_label = pred_proba > threshold<br>\n",
    "\n",
    " pred_proba是每个实例为真的概率<br>\n",
    " 假设阈值是0.75<br>\n",
    " pred_label里True就是概率大于0.75的<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### ②decision_function\n",
    "有些模块是没有pred_proba属性的，而有decision_function属性：决策值。<br>\n",
    "我们可以指定一个阈值，根据决策值和阈值的比较大小，来返回True/False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([78082.59408111])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 返回决策值decision_function\n",
    "y_scores = sgd_clf.decision_function([some_digit])  # some_digit 是之前我们看过的第36000个数，是5\n",
    "y_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold = 0  # 指定阈值为0\n",
    "y_some_digit_pred = (y_scores > threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 提高阀值可以降低召回率，提高阀值到200000，就错了这个图\n",
    "threshold = 200000  # 指定阈值为20000\n",
    "y_some_digit_pred = (y_scores > threshold)\n",
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 如何决定使用什么阀值\n",
    "###### 可以查看所以的决策值：\n",
    "* 返回预测结果<br>\n",
    "y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3 )  \n",
    "* 返回决策值<br>\n",
    "y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3,method=\"decision_function\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n",
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n",
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3,\n",
    "                             method=\"decision_function\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000,)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_scores.shape # 查看形状，可见有60000行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 有了y_scores，可以计算所有可能的阀值的精度和召回率：\n",
    "from sklearn.metrics import precision_recall_curve\n",
    "precisions, recalls, thresholds = precision_recall_curve(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplotlib 绘制精度和召回相对于阀值的函数图\n",
    "def plot_precision_recall_vs_threshold(precisions, recalls, thresholds):\n",
    "    plt.plot(thresholds, precisions[:-1], \"b--\", label=\"Precision\", linewidth=2)\n",
    "    plt.plot(thresholds, recalls[:-1], \"g-\", label=\"Recall\", linewidth=2)\n",
    "    plt.xlabel(\"Threshold\", fontsize=16)\n",
    "    plt.legend(loc=\"upper left\", fontsize=16)\n",
    "    plt.ylim([0, 1])\n",
    "\n",
    "plt.figure(figsize=(8, 4))\n",
    "plot_precision_recall_vs_threshold(precisions, recalls, thresholds)\n",
    "plt.xlim([-700000, 700000])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 这个没讲\n",
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_precision_vs_recall(precisions, recalls):\n",
    "    plt.plot(recalls, precisions, \"b-\", linewidth=2)\n",
    "    plt.xlabel(\"召回\", fontsize=16)\n",
    "    plt.ylabel(\"精度\", fontsize=16)\n",
    "    plt.axis([0, 1, 0, 1])\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plot_precision_vs_recall(precisions, recalls)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>课件性能考核05</u>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#####  通过选择阀值来实现最佳的精度/召回率权衡\n",
    "* 通过上上张图片，我们可以大概的估算一下，如果目标度为90%的时候，阈值大概是多少\n",
    "* 目测大概阈值是200000，然后代入200000，看看算出来的精度，(如果不对在调整阈值），如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9802989130434783"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_pred_90 = (y_scores > 200000)  # 代入阈值\n",
    "precision_score(y_train_5, y_train_pred_90)  # 计算精度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.26618705035971224"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred_90)  # 计算召回率"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.总结\n",
    "* 固定条件下精度和召回率是此消彼长的关系\n",
    "* 获得了一个90%以上高精度的分类器，往往导致召回低； 如果召回率低于目标，精度再高也不怎么有用\n",
    "* 如果工作中，需要99%的精度，你应该考虑🤔，召回率是多少，能不能满足需求？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "补充一个图，方便理解"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 这个是召回和精度的相关性线，不考虑阈值\n",
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_precision_vs_recall(precisions, recalls):\n",
    "    plt.plot(recalls, precisions, \"b-\", linewidth=2)\n",
    "    plt.xlabel(\"召回\", fontsize=16)\n",
    "    plt.ylabel(\"精度\", fontsize=16)\n",
    "    plt.axis([0, 1, 0, 1])\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plot_precision_vs_recall(precisions, recalls)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## 四，ROC 曲线"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的那个曲线叫PR曲线，接下来介绍ROC曲线<br>\n",
    "本质是 真正类率tpr和假正类率fpr（正确的分为正类的实例 和 错误的分为正类的负类实例比例）<br>\n",
    "与召回/精度曲线非常相似"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_curve  # 导入模块\n",
    "fpr, tpr, thresholds = roc_curve(y_train_5, y_scores)  # 代入真实的标签 和 决策值， 可获取真正类率、假正类率，阈值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 以图表形式展现\n",
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_roc_curve(fpr, tpr, label=None):\n",
    "    plt.plot(fpr, tpr, linewidth=2, label=label)\n",
    "    plt.plot([0, 1], [0, 1], 'k--')\n",
    "    plt.axis([0, 1, 0, 1])\n",
    "    plt.xlabel('假正类率', fontsize=16)\n",
    "    plt.ylabel('真正类率', fontsize=16)\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plot_roc_curve(fpr, tpr)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最理想的曲线应该是接近左上角那个点，远离这个虚线：真正类率是1， 假正类率是0 <br>\n",
    "换言之，曲线和虚线之间的面积（ROC）越大，那么分离器就越优秀"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9618359796347457"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算曲线下面积AUC的分值（取值范围是0.5到1），虚线是随机分类，与虚线重合的得分是0.5\n",
    "from sklearn.metrics import roc_auc_score\n",
    "\n",
    "roc_auc_score(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 召回率TPR越高，分类器的假正类FPR就越多（想拿到最多的5，自然拿错的机会就越大）\n",
    "* 虚线表示纯随机分类器的ROC曲线，好的分类器应该远离这条线，向左上角\n",
    "* 是使用精度/召回率 PR曲线，还是使用ROC？ 正类实例非常少或者更关注假正类（而不是假负类），选择PR，反之选ROC\n",
    "* 例如：前面例子ROC曲线很不错是因为跟负类 非5 相比， 正类 数据5 数量真的很少"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "<u>课件性能考核06</u>\n",
    "## 五，训练随机森林分类器，与SGD分类器进行比较\n",
    "* 比较 ROC曲线和ROC AUC分数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 获取训练集中每个实例的分数<br>\n",
    " RandomForestClassifier 没有descision_function(),但是拥有dict_proda()方法，sklearn中分类器都有这两个中的一个<br>\n",
    " dict_proda返回一个矩阵，每行一个实例，每列代表一个类别的概率，比如这个图片 70%是5<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\ensemble\\weight_boosting.py:29: DeprecationWarning: numpy.core.umath_tests is an internal NumPy module and should not be imported. It will be removed in a future NumPy release.\n",
      "  from numpy.core.umath_tests import inner1d\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "forest_clf = RandomForestClassifier(n_estimators=10, random_state=42)  # 10棵树，随机数是42\n",
    "y_probas_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3,\n",
    "                                    method=\"predict_proba\")  # 加上这个参数，就可以获取概率 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0.],\n",
       "       [1., 0.],\n",
       "       [1., 0.],\n",
       "       ...,\n",
       "       [1., 0.],\n",
       "       [1., 0.],\n",
       "       [1., 0.]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_probas_forest  # 查看概率[负概率，正概率]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 绘制ROC曲线，需要决策值不是概率，直接使用正类的概率作为决策值：\n",
    "y_scores_forest = y_probas_forest[:, 1]  # 获取正概率\n",
    "fpr_forest, tpr_forest, thresholds_forest = roc_curve(y_train_5,y_scores_forest)  # 获取假正类率，真正类率，阈值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., ..., 0., 0., 0.])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_scores_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 6))\n",
    "plt.plot(fpr, tpr, \"b:\", linewidth=2, label=\"SGD\")\n",
    "plot_roc_curve(fpr_forest, tpr_forest, \"Random Forest\")\n",
    "plt.legend(loc=\"lower right\", fontsize=16)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的代码虽然没有写sgd，但是上上面有过了，所以也会显示在图里<br>\n",
    "从上面可以看到随机森林比，sgd效果要好的多"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9926917553771822"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Rand 比SGD 好很多，ROC AUC的分数也高很多：\n",
    "roc_auc_score(y_train_5, y_scores_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9877314298460852"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 再看一下 精度和召回率 也很高\n",
    "y_train_pred_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3)\n",
    "precision_score(y_train_5, y_train_pred_forest)  # 精度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8168234643054787"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred_forest)  # 召回率"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 六，总结\n",
    "* 选择合适的指标利用交叉验证来对分类器进行评估\n",
    "* 选择满足需求的精度/召回率权衡\n",
    "* 使用ROC曲线和ROC AUC分数比较多个模型\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>多类别分类器01</u>\n",
    "# 多类别分类器\n",
    "* 尝试5 之外的检测\n",
    "* 多类别分类器 区分两个以上的类别：如 随机森里和朴素贝叶斯可以直接处理多个类别\n",
    "* 向量机svm和线性分类器只可以处理二元分类器，但可以通过间接的方法实现："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 一，二元分离器解决方案\n",
    "1. **OVA**： 将数字图片分类0到9，训练10个二元分类器，每个数字一个，检测一张图片时，<u>获取每个分类器的决策分数，哪个最高属于哪个</u>，称为一对多OvA\n",
    "2. **OVO**：为每一对数字训练一个二元分类器，区分0，1 区分0，2 区分1，2 称为一对一OvO策略，存在N个类别，<u>需要N*（N-1）/2个分类器，最后看哪个类别获胜最多</u>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 两种方案的优缺点\n",
    "* 大训练集合 OvA 速度快，所以OvA更常用，比如svm 在数据规模扩大时表现糟糕\n",
    "* 对于较小训练集合OvO比较有优势，同一时间OvO只需要用到部分训练集，两两类别进行训练\n",
    "* sklearn 检查到使用二元分类算法进行多类别分类任务，会自动运行OvA，SVM分类器除外"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**实践OVA**  <br>\n",
    "用sgd这个二元分类器，来训练一下多类别，示例如下：也能分辨出它是5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sgd_clf.fit(X_train, y_train)  # 拿训练集和训练标签来fit\n",
    "sgd_clf.predict([some_digit])  # 来估算一下"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "原因就是上面讲的：自动启动了OVA，内部实际上训练了10个二元分类器，获得图片的决策分数，然后选择了分数最高的类别<br>\n",
    "查看一下10个二元分类器的10个决策值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  60842.85434574, -449474.51551666, -182925.99009199,\n",
       "         -98420.54592915, -487608.1680893 ,   78082.59408111,\n",
       "        -905736.87490689, -436353.21422108, -703130.66327623,\n",
       "        -539025.77185027]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 返回10个分数，每个类别1个\n",
    "some_digit_scores = sgd_clf.decision_function([some_digit])\n",
    "some_digit_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmax(some_digit_scores)  # 查看一下最大的决策值的分类标签是几"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 看看有那些分类标签，目标类别列表会存储在classes_这个属性中，按值大小排列，\n",
    "sgd_clf.classes_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sgd_clf.classes_[np.argmax(some_digit_scores)] # 把该分类标签对应的值拿出来，看看值是什么，可见5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**实践OVO** <br>\n",
    "接下来我们看看，怎么使用OVO(不使用默认的OVA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用OvO策略，一对一或者一对多， 也能预测出是5\n",
    "from sklearn.multiclass import OneVsOneClassifier   # 导入模块\n",
    "ovo_clf = OneVsOneClassifier(SGDClassifier(max_iter=5, tol=-np.infty, random_state=42))\n",
    "ovo_clf.fit(X_train, y_train) # 训练\n",
    "ovo_clf.predict([some_digit]) # 预测"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ovo_clf.estimators_)  # 查看建立了几个分类器： 10*9/2=45个"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 二，看看随机森林 多类别分类器 直接处理多个类别"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用随机森林\n",
    "forest_clf.fit(X_train, y_train) # 训练\n",
    "forest_clf.predict([some_digit]) # 预测"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0. , 0. , 0. , 0.1, 0. , 0.8, 0. , 0. , 0.1, 0. ]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 随机森林直接将实例分为多个类别，\n",
    "# 调用predict_proba()可以获得分类器将每个实例分类为每个类别的概率列表，可见属于5号（第6个）分类的概率是最高是80%\n",
    "forest_clf.predict_proba([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>多类别分类器02</u>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 三，评估一下sdg分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n",
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n",
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.86312737, 0.86384319, 0.87513127])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用交叉验证评估SGD的准确率（精度）\n",
    "cross_val_score(sgd_clf, X_train, y_train, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n",
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n",
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.910018  , 0.90879544, 0.90983648])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将输入进行简单缩放 ，可以得到准确率 （精度）90 %以上\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "scaler = StandardScaler()  # 使用标准缩放\n",
    "X_train_scaled = scaler.fit_transform(X_train.astype(np.float64)) # 将数据转换成浮点类型，再缩放\n",
    "cross_val_score(sgd_clf, X_train_scaled, y_train, cv=3, scoring=\"accuracy\") # 缩放完之后，进行3次交叉验证，可见精度达到90%以上了"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果还需要进一步提高精度，那就需要分析错误<br>\n",
    "## 四，错误分析"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.项目流程\n",
    "（第二周，数据分析课程将过的流程）<br>\n",
    "1. 探索数据准备的选项\n",
    "2. 尝试多个模型\n",
    "3. 选择最佳模型并用GridSearchCV对参数进行微调\n",
    "4. 尽可能自动化\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.确定了一个相对合适的模型，进一步优化，分析其错误类型\n",
    " 假如我们确定了sdg是比较合适的模型<br>\n",
    "* 查看sdg的混淆矩阵\n",
    "* 使用cross_val_predict()进行预测\n",
    "* 调用confusion_matrix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n",
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n",
      "d:\\00-app\\python\\python38\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:123: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[5733,    3,   20,    9,   11,   48,   48,    7,   39,    5],\n",
       "       [   2, 6486,   49,   26,    6,   38,    7,   10,  108,   10],\n",
       "       [  53,   39, 5339,  103,   82,   25,   89,   56,  157,   15],\n",
       "       [  45,   43,  140, 5338,    2,  221,   35,   58,  149,  100],\n",
       "       [  20,   28,   41,    8, 5355,    9,   48,   31,   87,  215],\n",
       "       [  71,   46,   38,  190,   71, 4604,  112,   24,  169,   96],\n",
       "       [  33,   25,   52,    2,   42,   87, 5625,    7,   45,    0],\n",
       "       [  27,   24,   70,   28,   59,   10,    6, 5785,   13,  243],\n",
       "       [  52,  167,   75,  139,   14,  155,   60,   24, 5024,  141],\n",
       "       [  44,   33,   30,   87,  154,   32,    2,  199,   84, 5284]],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_pred = cross_val_predict(sgd_clf, X_train_scaled, y_train, cv=3)  # 进行预测，获得预测值\n",
    "conf_mx = confusion_matrix(y_train, y_train_pred)  # 代入实际值和预测值来获取混淆矩阵\n",
    "conf_mx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以看到上面的结果是获得了 一个 10x10的矩阵<br>\n",
    "对角线的值最高，对角线表示，实际值和预测值都是它自己的值（正确判断的值）<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplotlib的matshow 函数来查看混淆矩阵的图像表示 ：横轴表示真实值，纵轴表示预测值\n",
    "plt.matshow(conf_mx, cmap = plt.cm.gray)   # 代入混淆矩阵值，指定颜色域：数值越大越接近白色，越小越接近黑色\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 看起来不错，大多数图片都在主对角线上，说明它们被正确分类<br>\n",
    " 数字5 看起来比较暗：<br>\n",
    "  -可能1. 数字5图片较少  \n",
    "  -可能2. 分类器在数字5上执行效果不如其他数字上好<br>\n",
    " 数字1 看起来比较亮，说明1比较好判断，对于1的判断可以不用优化<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 假设把焦点放在错误上，为取得错误率，而不是错误绝对值，需要将混淆矩阵中每个值除以相应类别中的图片数量\n",
    "row_sums = conf_mx.sum(axis=1, keepdims=True)  # 获得混淆矩阵行上的行的合计值\n",
    "norm_conf_mx = conf_mx / row_sums  # 把混淆矩阵行上的数据/改行的合计值，对角线得到的值是正确率，其他得到错误率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 用0填充对角线 只保留错误，重新绘制\n",
    "np.fill_diagonal(norm_conf_mx, 0)   # 这行的作用是，把对角线的值用0来填充，\n",
    "plt.matshow(norm_conf_mx, cmap=plt.cm.gray)  # 颜色还是指定为灰（对角线就是黑色0）\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "观察上面的图形，<br>\n",
    "黑色的对角线可以不看，只看其他的格子，<br>\n",
    "每行代表实际类别，每列代表预测类别<br>\n",
    " 8，9列比较亮(错误率高)，说明许多图片被错误的分类为数字8，9<br>\n",
    " 类别8，9行也偏亮(错误率高)，说明数字8和9经常会被错误的分类成其他数字<br>\n",
    " 有些很暗，比如行1，大多数数字1都被正确的分类，一些和8混淆<br>\n",
    " 5和3是错误最多的<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.结论\n",
    "* 改进数字8和9的分类\n",
    "* 修正数字3和5的混淆\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>多类别分类器03</u>\n",
    "## 五，如何优化分类器\n",
    "* 尝试多收集这些数字的训练集\n",
    "* 开发一些新特征来改进分类器\n",
    "* 优化分类器算法\n",
    "* 使用pillow或opencv对图片预处理，让显示模型更突出\n",
    "* 分析单个错误"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来我们看看如何用图片处理来解决3和5的混淆"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 首先定义一个绘制图片的函数\n",
    "def plot_digits(instances, images_per_row=10, **options):\n",
    "    size = 28\n",
    "    images_per_row = min(len(instances), images_per_row)\n",
    "    images = [instance.reshape(size,size) for instance in instances]\n",
    "    n_rows = (len(instances) - 1) // images_per_row + 1\n",
    "    row_images = []\n",
    "    n_empty = n_rows * images_per_row - len(instances)\n",
    "    images.append(np.zeros((size, size * n_empty)))\n",
    "    for row in range(n_rows):\n",
    "        rimages = images[row * images_per_row : (row + 1) * images_per_row]\n",
    "        row_images.append(np.concatenate(rimages, axis=1))\n",
    "    image = np.concatenate(row_images, axis=0)\n",
    "    plt.imshow(image, cmap = matplotlib.cm.binary, **options)\n",
    "    plt.axis(\"off\")\n",
    "\n",
    "\n",
    "# 查看数字3和数字5的例子\n",
    "cl_a, cl_b = 3, 5  \n",
    "X_aa = X_train[(y_train == cl_a) & (y_train_pred == cl_a)] # 训练集中，实际是3，判断为3\n",
    "X_ab = X_train[(y_train == cl_a) & (y_train_pred == cl_b)] # 训练集中，实际是3，判断为5\n",
    "X_ba = X_train[(y_train == cl_b) & (y_train_pred == cl_a)] # 训练集中，实际是5，判断为3\n",
    "X_bb = X_train[(y_train == cl_b) & (y_train_pred == cl_b)] # 训练集中，实际是5，判断为5\n",
    "\n",
    "plt.figure(figsize=(8,8))\n",
    "plt.subplot(221); \n",
    "plot_digits(X_aa[:25], images_per_row=5)  # 选择其中25来显示\n",
    "plt.subplot(222); \n",
    "plot_digits(X_ab[:25], images_per_row=5)\n",
    "plt.subplot(223);\n",
    "plot_digits(X_ba[:25], images_per_row=5)\n",
    "plt.subplot(224); \n",
    "plot_digits(X_bb[:25], images_per_row=5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 左侧两个是被分类为3的图片<br>\n",
    " 右侧两个是被分类为5的图片<br>\n",
    " 大多数错误分类的图片看起来还是非常明显的错误<br>\n",
    " 原因：SGD是一个线性模型，它所做就是为每个像素分配一个各个类别的权重，当它看到新的图像，将加权后的像素强度汇总，从而得到一个分数进行分类\n",
    " <br>数字3和5在一部分像素位上有区别，所以分类器很容易将其弄混<br>\n",
    " 通过上面图像，如果书写3 的连接点左移，分类器可能将其分类为数字5，这个分类器对图像位移和旋转敏感<br>\n",
    " 减少混淆的方法之一，就是对图像进行预处理，确保位于中心位置并且没有旋转<br>\n",
    " 解决方法在录播课里没有，留成作业了"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>多类分类器04</u>\n",
    "## 六，多标签分类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 为每个实例产生多个类别 ，例如 照片识别多个人脸<br>\n",
    " 分类器经过训练可以识别小红，小白，小军，一张照片 里有 小红，小白<br>\n",
    " 经过分类器，应该输出[1,1,0]， 是小红，是小白，不是小军<br>\n",
    " 输出多个二元标签的分类系统称为多标签分类系统"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "KNeighbors，也就是有的资料上的KNN ,原理比较简单：<br>\n",
    "在训练集训练的时候，记住每个实例的点，和他对应的标签，<br>\n",
    "当预测新的数据的时候，计算新数据中实例的点 和训练集哪个实例的点最接近，就把对应的标签付给他。<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
       "           metric_params=None, n_jobs=1, n_neighbors=5, p=2,\n",
       "           weights='uniform')"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "y_train_large = (y_train >= 7) # 大于7的标签\n",
    "y_train_odd = (y_train % 2 == 1)  # 奇数的标签\n",
    "y_multilabel = np.c_[y_train_large, y_train_odd]  # 合并成一个多标签，应该是两个布尔元素：是否>= 7， 是否奇数\n",
    "\n",
    "knn_clf = KNeighborsClassifier() \n",
    "knn_clf.fit(X_train, y_multilabel)  # 使用KNN来训练一下数据，"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True]])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# knn支持多标签分类，不是所有的分类器都支持\n",
    "knn_clf.predict([some_digit])   # 拿我们已知值是5的数据来预测一下：得到了整齐的结果，不>=7，是奇数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 评估多标签分类器\n",
    "方法很多，方法之一就是测量每个标签的F1分数，或者其他二元分类器指标，然后简单平均："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9767999559168331"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##  因为下面的代码运算起来比较慢，就不要随便跑了\n",
    "# y_train_knn_pred = cross_val_predict(knn_clf, X_train, y_multilabel, cv=3)\n",
    "# f1_score(y_multilabel, y_train_knn_pred, average=\"macro\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面假设了所有标签都同等重要，也可以给每个标签设置一个权重（该目标标签实例的数量），设置average='weighted'\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 七，多输出分类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 例子：构建一个系统去除图片中的噪声，输入一张有噪声的图片，它将输入一张干净的数字图片，\n",
    "分类器输出是多个标签，一个像素一个标签，每个标签多个值0到255"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了做实验，我们先生成带噪音的数据集："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 增加噪声，目标将图片还原为原始图片 创建训练集和测试集\n",
    "noise = np.random.randint(0, 100, (len(X_train), 784)) # 生成噪音的随机数：取值范围是0-100，随机数是len(X_train)=700000行，784（28*28）列\n",
    "X_train_mod = X_train + noise  # 原来的训练集上加上噪音随机数\n",
    "noise = np.random.randint(0, 100, (len(X_test), 784))  # 生成噪音的随机数：测试集用的。\n",
    "X_test_mod = X_test + noise  # 原来的测试集上加上噪音随机数\n",
    "\n",
    "y_train_mod = X_train # 将原来的训练集拿来作为训练标签\n",
    "y_test_mod = X_test # 将原来的测试集拿来作为测试标签"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 先来看看，第5500个实例是什么\n",
    "some_index = 5500\n",
    "plt.subplot(121);plt.imshow(X_test_mod[some_index].reshape(28, 28), cmap = matplotlib.cm.binary)  # 训练集中第5500个图片\n",
    "plt.subplot(122);plt.imshow(y_test_mod[some_index].reshape(28, 28), cmap = matplotlib.cm.binary)  # 训练标签中第5500个图片\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "knn_clf.fit(X_train_mod, y_train_mod)  # 训练数据\n",
    "clean_digit = knn_clf.predict([X_test_mod[some_index]])  # 预测"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(clean_digit.reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "# 作业一 ， 尝试使用其他分离器预测Minst值\n",
    "## 决策树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0.],\n",
       "       [0., 1.],\n",
       "       [1., 0.],\n",
       "       ...,\n",
       "       [1., 0.],\n",
       "       [1., 0.],\n",
       "       [1., 0.]])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 导入决策树\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "\n",
    "tree_clf = DecisionTreeClassifier(random_state=42) # 实例化对象\n",
    "# 获得决策值\n",
    "y_score_tree = cross_val_predict(tree_clf, X_train, y_train_5, cv=3,method = 'predict_proba')  # 进行预测\n",
    "y_score_tree "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 切片处理\n",
    "y_score_tree = y_score_tree [:,1]  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 检测ROC曲线\n",
    "fpr_tree, tpr_tree, threshold_tree = roc_curve(y_train_5, y_score_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 6))  # 显示一下图片\n",
    "plt.plot(fpr, tpr, \"b:\", linewidth=2, label=\"SGD\")\n",
    "plot_roc_curve(fpr_forest, tpr_forest, \"Random Forest\")\n",
    "plot_roc_curve(fpr_tree, tpr_tree, \"Decision Tree\")\n",
    "plt.legend(loc=\"lower right\", fontsize=16)\n",
    "plt.show()  # plt继承了上面的图片，所以SGD也显示了"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9169862761850273"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import roc_auc_score\n",
    "# 计算roc_auc分数\n",
    "roc_auc_score(y_train_5, y_score_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
